﻿
/* Print the contents of a page by sending the contents to the function */
//function PrintPage(contents) {

//    var html = "<html>";
//    html += contents;
//    html += "</html>";

//    var printWin = window.open('', '', 'left=0,top=0,width=1,height=1,toolbar=0,scrollbars=0,status  =0');
//    printWin.document.write(html);
//    printWin.document.close();
//    printWin.focus();
//    printWin.print();
//    printWin.close();

//}

//Load event of the page
//$( function ()
//{


//    //$( ".info" ).corner();
//    
//    //Style buttons
//   // $( "button" ).button();

//    //Button Tooltip
//  //  $( ".tip" ).tooltip( { position: "center right", offset: [-2, 10], effect: "fade", opacity: 0.7 } );
//    //Style Select options [dropdowns]
//  //  
//   // $( ".ui-widget" ).tooltip( { position: "center right", offset: [-2, 10], effect: "fade", opacity: 0.7 } );

//  

//   
//    //Create a checkbox
//    //$( ".checkbox" ).click( function ()
//    //{
//    //    if ( $( this ).children( "input" ).attr( "checked" ) )
//    //    {
//    //        // uncheck
//    //        $( this ).children( "input" ).attr( { checked: "" } );
//    //        $( this ).removeClass( "checked" );
//    //        $( this ).addClass( "unchecked" );
//    //    } else
//    //    {
//    //        // check
//    //        $( this ).children( "input" ).attr( { checked: "checked" } );
//    //        $( this ).removeClass( "unchecked" );
//    //        $( this ).addClass( "checked" );
//    //    }
//    //} );

//} );

//function CreateLogo() {

////var canvas = document.createElement("canvas");
//var canvas = document.getElementById("canvas");//Get the canvas object
//var ctx = canvas.getContext("2d"); //Create a context for the canvas tag, references to the contents of the object

//draw(ctx); //Call the draw method

////return canvas;

//}


///*  The draw method that create the Logo  */
//function draw(ctx) {
//    var gradient;

//    // layer1/
//    ctx.save();
//    ctx.font = "72.0px 'Californian FB'";
//    ctx.fillStyle = "rgb(164, 192, 249)";
//    ctx.fillText("&", 56.3, 88.5);

//    // layer1/Compound Path
//    ctx.beginPath();

//    // layer1/Compound Path/Path
//    ctx.moveTo(29.1, 68.4);
//    ctx.bezierCurveTo(27.5, 60.6, 29.3, 49.7, 23.2, 41.4);
//    ctx.bezierCurveTo(20.2, 37.4, 11.0, 44.3, 0.0, 55.8);
//    ctx.bezierCurveTo(6.2, 48.2, 12.7, 22.7, 22.8, 14.3);
//    ctx.bezierCurveTo(23.0, 14.1, 23.7, 13.8, 23.4, 13.8);
//    ctx.bezierCurveTo(20.9, 14.2, 15.8, 2.0, 26.6, 0.1);
//    ctx.bezierCurveTo(33.9, -1.2, 37.5, 11.5, 28.8, 13.5);
//    ctx.bezierCurveTo(27.6, 13.8, 28.7, 12.3, 32.7, 14.4);
//    ctx.bezierCurveTo(38.3, 17.5, 45.6, 19.3, 45.6, 19.3);
//    ctx.bezierCurveTo(39.0, 19.6, 29.4, 21.3, 29.5, 28.9);
//    ctx.bezierCurveTo(29.8, 48.0, 29.1, 68.4, 29.1, 68.4);
//    ctx.closePath();
//    gradient = ctx.createLinearGradient(0.0, 34.2, 45.6, 34.2);
//    gradient.addColorStop(0.00, "rgb(255, 255, 255)");
//    gradient.addColorStop(0.00, "rgb(0, 175, 215)");
//    gradient.addColorStop(0.00, "rgb(94, 245, 255)");
//    gradient.addColorStop(0.33, "rgb(94, 222, 255)");
//    gradient.addColorStop(0.99, "rgb(0, 137, 222)");
//    ctx.fillStyle = gradient;
//    ctx.fill();

//    // layer1/Path
//    ctx.beginPath();
//    ctx.moveTo(68.5, 82.9);
//    ctx.bezierCurveTo(64.5, 74.0, 60.0, 61.7, 50.7, 53.3);
//    ctx.bezierCurveTo(46.2, 49.3, 40.2, 64.5, 37.1, 81.8);
//    ctx.bezierCurveTo(35.5, 71.2, 34.0, 32.1, 47.2, 19.9);
//    ctx.bezierCurveTo(47.4, 19.6, 48.1, 19.0, 47.8, 19.1);
//    ctx.bezierCurveTo(44.9, 19.8, 35.8, 6.9, 48.0, 1.9);
//    ctx.bezierCurveTo(56.3, -1.5, 63.7, 12.8, 54.0, 17.4);
//    ctx.bezierCurveTo(52.7, 18.0, 53.3, 17.1, 58.7, 16.8);
//    ctx.bezierCurveTo(67.0, 16.2, 76.6, 15.5, 76.6, 15.5);
//    ctx.bezierCurveTo(69.0, 17.6, 56.7, 26.5, 58.8, 35.6);
//    ctx.bezierCurveTo(64.1, 58.3, 68.5, 82.9, 68.5, 82.9);
//    ctx.closePath();
//    gradient = ctx.createLinearGradient(36.1, 42.2, 76.6, 42.2);
//    gradient.addColorStop(0.00, "rgb(255, 255, 255)");
//    gradient.addColorStop(0.27, "rgb(126, 207, 231)");
//    gradient.addColorStop(0.62, "rgb(0, 175, 215)");
//    gradient.addColorStop(0.78, "rgb(0, 137, 168)");
//    gradient.addColorStop(0.99, "rgb(0, 111, 139)");
//    ctx.fillStyle = gradient;
//    ctx.fill();

//    // layer1/RISK
//    ctx.font = "54.8px 'Rockwell Condensed'";
//    ctx.save();
//    ctx.transform(0.725, 0.000, 0.000, 1.000, 76.6, 54.2);
//    ctx.fillStyle = "rgb(50, 129, 50)";
//    ctx.fillText("RISK", 0, 0);
//    ctx.restore();

//    // layer1/COMPLIANCE
//    ctx.font = "36.0px 'Calibri'";
//    ctx.fillStyle = "rgb(112, 206, 112)";
//    ctx.fillText("COMPLIANCE", 105.2, 78.9);
//    ctx.restore();

//}

//function RememberIcon() { }











//////Corers
/////*!
////* jQuery corner plugin: simple corner rounding
////* Examples and documentation at: http://jquery.malsup.com/corner/
////* version 2.12 (23-MAY-2011)
////* Requires jQuery v1.3.2 or later
////* Dual licensed under the MIT and GPL licenses:
////* http://www.opensource.org/licenses/mit-license.php
////* http://www.gnu.org/licenses/gpl.html
////* Authors: Dave Methvin and Mike Alsup
////*/

/////**
////*  corner() takes a single string argument:  $('#myDiv').corner("effect corners width")
////*
////*  effect:  name of the effect to apply, such as round, bevel, notch, bite, etc (default is round). 
////*  corners: one or more of: top, bottom, tr, tl, br, or bl.  (default is all corners)
////*  width:   width of the effect; in the case of rounded corners this is the radius. 
////*           specify this value using the px suffix such as 10px (yes, it must be pixels).
////*/
////; (function ($) {

////    var style = document.createElement('div').style,
////    moz = style['MozBorderRadius'] !== undefined,
////    webkit = style['WebkitBorderRadius'] !== undefined,
////    radius = style['borderRadius'] !== undefined || style['BorderRadius'] !== undefined,
////    mode = document.documentMode || 0,
////    noBottomFold = $.browser.msie && (($.browser.version < 8 && !mode) || mode < 8),

////    expr = $.browser.msie && (function () {
////        var div = document.createElement('div');
////        try { div.style.setExpression('width', '0+0'); div.style.removeExpression('width'); }
////        catch (e) { return false; }
////        return true;
////    })();

////    $.support = $.support || {};
////    $.support.borderRadius = moz || webkit || radius; // so you can do:  if (!$.support.borderRadius) $('#myDiv').corner();

////    function sz(el, p) {
////        return parseInt($.css(el, p)) || 0;
////    };
////    function hex2(s) {
////        s = parseInt(s).toString(16);
////        return (s.length < 2) ? '0' + s : s;
////    };
////    function gpc(node) {
////        while (node) {
////            var v = $.css(node, 'backgroundColor'), rgb;
////            if (v && v != 'transparent' && v != 'rgba(0, 0, 0, 0)') {
////                if (v.indexOf('rgb') >= 0) {
////                    rgb = v.match(/\d+/g);
////                    return '#' + hex2(rgb[0]) + hex2(rgb[1]) + hex2(rgb[2]);
////                }
////                return v;
////            }
////            if (node.nodeName.toLowerCase() == 'html')
////                break;
////            node = node.parentNode; // keep walking if transparent
////        }
////        return '#ffffff';
////    };

////    function getWidth(fx, i, width) {
////        switch (fx) {
////            case 'round': return Math.round(width * (1 - Math.cos(Math.asin(i / width))));
////            case 'cool': return Math.round(width * (1 + Math.cos(Math.asin(i / width))));
////            case 'sharp': return width - i;
////            case 'bite': return Math.round(width * (Math.cos(Math.asin((width - i - 1) / width))));
////            case 'slide': return Math.round(width * (Math.atan2(i, width / i)));
////            case 'jut': return Math.round(width * (Math.atan2(width, (width - i - 1))));
////            case 'curl': return Math.round(width * (Math.atan(i)));
////            case 'tear': return Math.round(width * (Math.cos(i)));
////            case 'wicked': return Math.round(width * (Math.tan(i)));
////            case 'long': return Math.round(width * (Math.sqrt(i)));
////            case 'sculpt': return Math.round(width * (Math.log((width - i - 1), width)));
////            case 'dogfold':
////            case 'dog': return (i & 1) ? (i + 1) : width;
////            case 'dog2': return (i & 2) ? (i + 1) : width;
////            case 'dog3': return (i & 3) ? (i + 1) : width;
////            case 'fray': return (i % 2) * width;
////            case 'notch': return width;
////            case 'bevelfold':
////            case 'bevel': return i + 1;
////            case 'steep': return i / 2 + 1;
////            case 'invsteep': return (width - i) / 2 + 1;
////        }
////    };

////    $.fn.corner = function (options) {
////        // in 1.3+ we can fix mistakes with the ready state
////        if (this.length == 0) {
////            if (!$.isReady && this.selector) {
////                var s = this.selector, c = this.context;
////                $(function () {
////                    $(s, c).corner(options);
////                });
////            }
////            return this;
////        }

////        return this.each(function (index) {
////            var $this = $(this),
////            // meta values override options
////            o = [$this.attr($.fn.corner.defaults.metaAttr) || '', options || ''].join(' ').toLowerCase(),
////            keep = /keep/.test(o),                       // keep borders?
////            cc = ((o.match(/cc:(#[0-9a-f]+)/) || [])[1]),  // corner color
////            sc = ((o.match(/sc:(#[0-9a-f]+)/) || [])[1]),  // strip color
////            width = parseInt((o.match(/(\d+)px/) || [])[1]) || 10, // corner width
////            re = /round|bevelfold|bevel|notch|bite|cool|sharp|slide|jut|curl|tear|fray|wicked|sculpt|long|dog3|dog2|dogfold|dog|invsteep|steep/,
////            fx = ((o.match(re) || ['round'])[0]),
////            fold = /dogfold|bevelfold/.test(o),
////            edges = { T: 0, B: 1 },
////            opts = {
////                TL: /top|tl|left/.test(o), TR: /top|tr|right/.test(o),
////                BL: /bottom|bl|left/.test(o), BR: /bottom|br|right/.test(o)
////            },
////            // vars used in func later
////            strip, pad, cssHeight, j, bot, d, ds, bw, i, w, e, c, common, $horz;

////            if (!opts.TL && !opts.TR && !opts.BL && !opts.BR)
////                opts = { TL: 1, TR: 1, BL: 1, BR: 1 };

////            // support native rounding
////            if ($.fn.corner.defaults.useNative && fx == 'round' && (radius || moz || webkit) && !cc && !sc) {
////                if (opts.TL)
////                    $this.css(radius ? 'border-top-left-radius' : moz ? '-moz-border-radius-topleft' : '-webkit-border-top-left-radius', width + 'px');
////                if (opts.TR)
////                    $this.css(radius ? 'border-top-right-radius' : moz ? '-moz-border-radius-topright' : '-webkit-border-top-right-radius', width + 'px');
////                if (opts.BL)
////                    $this.css(radius ? 'border-bottom-left-radius' : moz ? '-moz-border-radius-bottomleft' : '-webkit-border-bottom-left-radius', width + 'px');
////                if (opts.BR)
////                    $this.css(radius ? 'border-bottom-right-radius' : moz ? '-moz-border-radius-bottomright' : '-webkit-border-bottom-right-radius', width + 'px');
////                return;
////            }

////            strip = document.createElement('div');
////            $(strip).css({
////                overflow: 'hidden',
////                height: '1px',
////                minHeight: '1px',
////                fontSize: '1px',
////                backgroundColor: sc || 'transparent',
////                borderStyle: 'solid'
////            });

////            pad = {
////                T: parseInt($.css(this, 'paddingTop')) || 0, R: parseInt($.css(this, 'paddingRight')) || 0,
////                B: parseInt($.css(this, 'paddingBottom')) || 0, L: parseInt($.css(this, 'paddingLeft')) || 0
////            };

////            if (typeof this.style.zoom != undefined) this.style.zoom = 1; // force 'hasLayout' in IE
////            if (!keep) this.style.border = 'none';
////            strip.style.borderColor = cc || gpc(this.parentNode);
////            cssHeight = $(this).outerHeight();

////            for (j in edges) {
////                bot = edges[j];
////                // only add stips if needed
////                if ((bot && (opts.BL || opts.BR)) || (!bot && (opts.TL || opts.TR))) {
////                    strip.style.borderStyle = 'none ' + (opts[j + 'R'] ? 'solid' : 'none') + ' none ' + (opts[j + 'L'] ? 'solid' : 'none');
////                    d = document.createElement('div');
////                    $(d).addClass('jquery-corner');
////                    ds = d.style;

////                    bot ? this.appendChild(d) : this.insertBefore(d, this.firstChild);

////                    if (bot && cssHeight != 'auto') {
////                        if ($.css(this, 'position') == 'static')
////                            this.style.position = 'relative';
////                        ds.position = 'absolute';
////                        ds.bottom = ds.left = ds.padding = ds.margin = '0';
////                        if (expr)
////                            ds.setExpression('width', 'this.parentNode.offsetWidth');
////                        else
////                            ds.width = '100%';
////                    }
////                    else if (!bot && $.browser.msie) {
////                        if ($.css(this, 'position') == 'static')
////                            this.style.position = 'relative';
////                        ds.position = 'absolute';
////                        ds.top = ds.left = ds.right = ds.padding = ds.margin = '0';

////                        // fix ie6 problem when blocked element has a border width
////                        if (expr) {
////                            bw = sz(this, 'borderLeftWidth') + sz(this, 'borderRightWidth');
////                            ds.setExpression('width', 'this.parentNode.offsetWidth - ' + bw + '+ "px"');
////                        }
////                        else
////                            ds.width = '100%';
////                    }
////                    else {
////                        ds.position = 'relative';
////                        ds.margin = !bot ? '-' + pad.T + 'px -' + pad.R + 'px ' + (pad.T - width) + 'px -' + pad.L + 'px' :
////                                        (pad.B - width) + 'px -' + pad.R + 'px -' + pad.B + 'px -' + pad.L + 'px';
////                    }

////                    for (i = 0; i < width; i++) {
////                        w = Math.max(0, getWidth(fx, i, width));
////                        e = strip.cloneNode(false);
////                        e.style.borderWidth = '0 ' + (opts[j + 'R'] ? w : 0) + 'px 0 ' + (opts[j + 'L'] ? w : 0) + 'px';
////                        bot ? d.appendChild(e) : d.insertBefore(e, d.firstChild);
////                    }

////                    if (fold && $.support.boxModel) {
////                        if (bot && noBottomFold) continue;
////                        for (c in opts) {
////                            if (!opts[c]) continue;
////                            if (bot && (c == 'TL' || c == 'TR')) continue;
////                            if (!bot && (c == 'BL' || c == 'BR')) continue;

////                            common = { position: 'absolute', border: 'none', margin: 0, padding: 0, overflow: 'hidden', backgroundColor: strip.style.borderColor };
////                            $horz = $('<div/>').css(common).css({ width: width + 'px', height: '1px' });
////                            switch (c) {
////                                case 'TL': $horz.css({ bottom: 0, left: 0 }); break;
////                                case 'TR': $horz.css({ bottom: 0, right: 0 }); break;
////                                case 'BL': $horz.css({ top: 0, left: 0 }); break;
////                                case 'BR': $horz.css({ top: 0, right: 0 }); break;
////                            }
////                            d.appendChild($horz[0]);

////                            var $vert = $('<div/>').css(common).css({ top: 0, bottom: 0, width: '1px', height: width + 'px' });
////                            switch (c) {
////                                case 'TL': $vert.css({ left: width }); break;
////                                case 'TR': $vert.css({ right: width }); break;
////                                case 'BL': $vert.css({ left: width }); break;
////                                case 'BR': $vert.css({ right: width }); break;
////                            }
////                            d.appendChild($vert[0]);
////                        }
////                    }
////                }
////            }
////        });
////    };

////    $.fn.uncorner = function () {
////        if (radius || moz || webkit)
////            this.css(radius ? 'border-radius' : moz ? '-moz-border-radius' : '-webkit-border-radius', 0);
////        $('div.jquery-corner', this).remove();
////        return this;
////    };

////    // expose options
////    $.fn.corner.defaults = {
////        useNative: true, // true if plugin should attempt to use native browser support for border radius rounding
////        metaAttr: 'data-corner' // name of meta attribute to use for options
////    };

////})(jQuery);



















